if(!dojo._hasResource["dijit.Menu"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dijit.Menu"] = true;

dojo.provide("dijit.Menu");



dojo.require("dijit._Widget");

dojo.require("dijit._Container");

dojo.require("dijit._Templated");



dojo.declare(

	"dijit.Menu",

	[dijit._Widget, dijit._Templated, dijit._KeyNavContainer],

{

	constructor: function() {

		this._bindings = [];

	},



	templateString:

			'<table class="dijit dijitMenu dijitReset dijitMenuTable" waiRole="menu" dojoAttachEvent="onkeypress:_onKeyPress">' +

				'<tbody class="dijitReset" dojoAttachPoint="containerNode"></tbody>'+

			'</table>',



	// targetNodeIds: String[]

	//	Array of dom node ids of nodes to attach to.

	//	Fill this with nodeIds upon widget creation and it becomes context menu for those nodes.

	targetNodeIds: [],



	// contextMenuForWindow: Boolean

	//	if true, right clicking anywhere on the window will cause this context menu to open;

	//	if false, must specify targetNodeIds

	contextMenuForWindow: false,



	// parentMenu: Widget

	// pointer to menu that displayed me

	parentMenu: null,



	// popupDelay: Integer

	//	number of milliseconds before hovering (without clicking) causes the popup to automatically open

	popupDelay: 500,



	// _contextMenuWithMouse: Boolean

	//	used to record mouse and keyboard events to determine if a context

	//	menu is being opened with the keyboard or the mouse

	_contextMenuWithMouse: false,



	postCreate: function(){

		if(this.contextMenuForWindow){

			this.bindDomNode(dojo.body());

		}else{

			dojo.forEach(this.targetNodeIds, this.bindDomNode, this);

		}

		this.connectKeyNavHandlers([dojo.keys.UP_ARROW], [dojo.keys.DOWN_ARROW]);

	},



	startup: function(){

		dojo.forEach(this.getChildren(), function(child){ child.startup(); });

		this.startupKeyNavChildren();

	},



	onExecute: function(){

		// summary: attach point for notification about when a menu item has been executed

	},



	onCancel: function(/*Boolean*/ closeAll){

		// summary: attach point for notification about when the user cancels the current menu

	},



	_moveToPopup: function(/*Event*/ evt){

		if(this.focusedChild && this.focusedChild.popup && !this.focusedChild.disabled){

			this.focusedChild._onClick(evt);

		}

	},



	_onKeyPress: function(/*Event*/ evt){

		// summary

		//	Handle keyboard based menu navigation.

		if(evt.ctrlKey || evt.altKey){ return; }



		switch(evt.keyCode){

			case dojo.keys.RIGHT_ARROW:

				this._moveToPopup(evt);

				dojo.stopEvent(evt);

				break;

			case dojo.keys.LEFT_ARROW:

				if(this.parentMenu){

					this.onCancel(false);

				}else{

					dojo.stopEvent(evt);

				}

				break;

		}

	},



	onItemHover: function(/*MenuItem*/ item){

		this.focusChild(item);



		if(this.focusedChild.popup && !this.focusedChild.disabled && !this.hover_timer){

			this.hover_timer = setTimeout(dojo.hitch(this, "_openPopup"), this.popupDelay);

		}

	},



	_onChildBlur: function(item){

		// Close all popups that are open and descendants of this menu

		dijit.popup.close(item.popup);

		item._blur();

		this._stopPopupTimer();

	},



	onItemUnhover: function(/*MenuItem*/ item){

	},



	_stopPopupTimer: function(){

		if(this.hover_timer){

			clearTimeout(this.hover_timer);

			this.hover_timer = null;

		}

	},



	_getTopMenu: function(){

		for(var top=this; top.parentMenu; top=top.parentMenu);

		return top;

	},



	onItemClick: function(/*Widget*/ item){

		// summary: user defined function to handle clicks on an item

		// summary: internal function for clicks

		if(item.disabled){ return false; }



		if(item.popup){

			if(!this.is_open){

				this._openPopup();

			}

		}else{

			// before calling user defined handler, close hierarchy of menus

			// and restore focus to place it was when menu was opened

			this.onExecute();



			// user defined handler for click

			item.onClick();

		}

	},



	// thanks burstlib!

	_iframeContentWindow: function(/* HTMLIFrameElement */iframe_el) {

		//	summary

		//	returns the window reference of the passed iframe

		var win = dijit.getDocumentWindow(dijit.Menu._iframeContentDocument(iframe_el)) ||

			// Moz. TODO: is this available when defaultView isn't?

			dijit.Menu._iframeContentDocument(iframe_el)['__parent__'] ||

			(iframe_el.name && document.frames[iframe_el.name]) || null;

		return win;	//	Window

	},



	_iframeContentDocument: function(/* HTMLIFrameElement */iframe_el){

		//	summary

		//	returns a reference to the document object inside iframe_el

		var doc = iframe_el.contentDocument // W3

			|| (iframe_el.contentWindow && iframe_el.contentWindow.document) // IE

			|| (iframe_el.name && document.frames[iframe_el.name] && document.frames[iframe_el.name].document)

			|| null;

		return doc;	//	HTMLDocument

	},



	bindDomNode: function(/*String|DomNode*/ node){

		// summary: attach menu to given node
		node = dojo.byId(node);



		//TODO: this is to support context popups in Editor.  Maybe this shouldn't be in dijit.Menu

		var win = dijit.getDocumentWindow(node.ownerDocument);

		if(node.tagName.toLowerCase()=="iframe"){

			win = this._iframeContentWindow(node);

			node = dojo.withGlobal(win, dojo.body);

		}



		// to capture these events at the top level,

		// attach to document, not body

		var cn = (node == dojo.body() ? dojo.doc : node);



		node[this.id] = this._bindings.push([

			dojo.connect(cn, "oncontextmenu", this, "_openMyself"),

			dojo.connect(cn, "onkeydown", this, "_contextKey"),

			dojo.connect(cn, "onmousedown", this, "_contextMouse")

		]);

	},



	unBindDomNode: function(/*String|DomNode*/ nodeName){

		// summary: detach menu from given node

		var node = dojo.byId(nodeName);

		var bid = node[this.id]-1, b = this._bindings[bid];

		dojo.forEach(b, dojo.disconnect);

		delete this._bindings[bid];

	},



	_contextKey: function(e){

		this._contextMenuWithMouse = false;

		if (e.keyCode == dojo.keys.F10) {

			dojo.stopEvent(e);

			if (e.shiftKey && e.type=="keydown") {

				// FF: copying the wrong property from e will cause the system

				// context menu to appear in spite of stopEvent. Don't know

				// exactly which properties cause this effect.

				var _e = { target: e.target, pageX: e.pageX, pageY: e.pageY };

				_e.preventDefault = _e.stopPropagation = function(){};

				// IE: without the delay, focus work in "open" causes the system

				// context menu to appear in spite of stopEvent.

				window.setTimeout(dojo.hitch(this, function(){ this._openMyself(_e); }), 1);

			}

		}

	},



	_contextMouse: function(e){

		this._contextMenuWithMouse = true;

	},



	_openMyself: function(/*Event*/ e){

		// summary:

		//		Internal function for opening myself when the user

		//		does a right-click or something similar



		dojo.stopEvent(e);



		// Get coordinates.

		// if we are opening the menu with the mouse or on safari open

		// the menu at the mouse cursor

		// (Safari does not have a keyboard command to open the context menu

		// and we don't currently have a reliable way to determine

		// _contextMenuWithMouse on Safari)

		var x,y;

		if(dojo.isSafari || this._contextMenuWithMouse){

			x=e.pageX;

			y=e.pageY;

		}else{

			// otherwise open near e.target

			var coords = dojo.coords(e.target, true);

			x = coords.x + 10;

			y = coords.y + 10;

		}



		var self=this;

		var savedFocus = dijit.getFocus(this);

		function closeAndRestoreFocus(){

			// user has clicked on a menu or popup

			// dijit.focus(savedFocus);

			dijit.popup.close(self);

		}

		dijit.popup.open({

			popup: this,

			x: x,

			y: y,

			onExecute: closeAndRestoreFocus,

			onCancel: closeAndRestoreFocus,

			orient: this.isLeftToRight() ? 'L' : 'R'

		});

		this.focus();



		this._onBlur = function(){

			// Usually the parent closes the child widget but if this is a context

			// menu then there is no parent

			dijit.popup.close(this);

			// don't try to restore focus; user has clicked another part of the screen

			// and set focus there

		}

	},



	onOpen: function(/*Event*/ e){

		// summary

		//		Open menu relative to the mouse

		this.isShowingNow = true;

	},



	onClose: function(){

		// summary: callback when this menu is closed

		this._stopPopupTimer();

		this.parentMenu = null;

		this.isShowingNow = false;

		this.currentPopup = null;

		if(this.focusedChild){

			this._onChildBlur(this.focusedChild);

			this.focusedChild = null;

		}

	},



	_openPopup: function(){

		// summary: open the popup to the side of the current menu item

		this._stopPopupTimer();

		var from_item = this.focusedChild;

		var popup = from_item.popup;



		if(popup.isShowingNow){ return; }

		popup.parentMenu = this;

		var self = this;

		dijit.popup.open({

			parent: this,

			popup: popup,

			around: from_item.arrowCell,

			orient: this.isLeftToRight() ? {'TR': 'TL', 'TL': 'TR'} : {'TL': 'TR', 'TR': 'TL'},

			onCancel: function(){

				// called when the child menu is canceled

				dijit.popup.close(popup);

				from_item.focus();	// put focus back on my node

				self.currentPopup = null;

			}

		});



		this.currentPopup = popup;



		if(popup.focus){

			popup.focus();

		}

	}

}

);



dojo.declare(

	"dijit.MenuItem",

	[dijit._Widget, dijit._Templated, dijit._Contained],

{

	// summary

	//	A line item in a Menu2



	// Make 3 columns

	//   icon, label, and expand arrow (BiDi-dependent) indicating sub-menu

	templateString:

		 '<tr class="dijitReset dijitMenuItem"'

		+'dojoAttachEvent="onmouseenter:_onHover,onmouseleave:_onUnhover,ondijitclick:_onClick">'

		+'<td class="dijitReset"><div class="dijitMenuItemIcon ${iconClass}" dojoAttachPoint="iconNode" ></div></td>'

		+'<td tabIndex="-1" class="dijitReset dijitMenuItemLabel" dojoAttachPoint="containerNode" waiRole="menuitem"></td>'

		+'<td class="dijitReset" dojoAttachPoint="arrowCell">'

			+'<div class="dijitMenuExpand" dojoAttachPoint="expand" style="display:none">'

			+'<span class="dijitInline dijitArrowNode dijitMenuExpandInner">+</span>'

			+'</div>'

		+'</td>'

		+'</tr>',



	// label: String

	//	menu text

	label: '',



	// iconClass: String

	//	class to apply to div in button to make it display an icon

	iconClass: "",



	// disabled: Boolean

	//  if true, the menu item is disabled

	//  if false, the menu item is enabled

	disabled: false,



	postCreate: function(){

		dojo.setSelectable(this.domNode, false);

		this.setDisabled(this.disabled);

		if(this.label){

			this.containerNode.innerHTML=this.label;

		}

	},



	_onHover: function(){

		// summary: callback when mouse is moved onto menu item

		this.getParent().onItemHover(this);

	},



	_onUnhover: function(){

		// summary: callback when mouse is moved off of menu item

		// if we are unhovering the currently selected item

		// then unselect it

		this.getParent().onItemUnhover(this);

	},



	_onClick: function(evt){

		this.getParent().onItemClick(this);

		dojo.stopEvent(evt);

	},



	onClick: function() {

		// summary

		//	User defined function to handle clicks

	},



	focus: function(){

		dojo.addClass(this.domNode, 'dijitMenuItemHover');

		try{

			dijit.focus(this.containerNode);

		}catch(e){

			// this throws on IE (at least) in some scenarios

		}

	},



	_blur: function(){

		dojo.removeClass(this.domNode, 'dijitMenuItemHover');

	},



	setDisabled: function(/*Boolean*/ value){

		// summary: enable or disable this menu item

		this.disabled = value;

		dojo[value ? "addClass" : "removeClass"](this.domNode, 'dijitMenuItemDisabled');

		dijit.setWaiState(this.containerNode, 'disabled', value ? 'true' : 'false');

	}

});



dojo.declare(

	"dijit.PopupMenuItem",

	dijit.MenuItem,

{

	_fillContent: function(){

		// my inner HTML contains both the menu item text and a popup widget, like

		// <div dojoType="dijit.PopupMenuItem">

		//		<span>pick me</span>

		//		<popup> ... </popup>

		// </div>

		// the first part holds the menu item text and the second part is the popup

		if(this.srcNodeRef){

			var nodes = dojo.query("*", this.srcNodeRef);

			dijit.PopupMenuItem.superclass._fillContent.call(this, nodes[0]);



			// save pointer to srcNode so we can grab the drop down widget after it's instantiated

			this.dropDownContainer = this.srcNodeRef;

		}

	},



	startup: function(){

		// we didn't copy the dropdown widget from the this.srcNodeRef, so it's in no-man's

		// land now.  move it to document.body.

		if(!this.popup){

			var node = dojo.query("[widgetId]", this.dropDownContainer)[0];

			this.popup = dijit.byNode(node);

		}

		dojo.body().appendChild(this.popup.domNode);



		this.popup.domNode.style.display="none";

		dojo.addClass(this.expand, "dijitMenuExpandEnabled");

		dojo.style(this.expand, "display", "");

		dijit.setWaiState(this.containerNode, "haspopup", "true");

	}

});



dojo.declare(

	"dijit.MenuSeparator",

	[dijit._Widget, dijit._Templated, dijit._Contained],

{

	// summary

	//	A line between two menu items



	templateString: '<tr class="dijitMenuSeparator"><td colspan=3>'

			+'<div class="dijitMenuSeparatorTop"></div>'

			+'<div class="dijitMenuSeparatorBottom"></div>'

			+'</td></tr>',



	postCreate: function(){

		dojo.setSelectable(this.domNode, false);

	},

	

	isFocusable: function(){

		// summary:

		//		over ride to always return false

		return false;

	}

});



}

